home *** CD-ROM | disk | FTP | other *** search
/ User's Choice Windows CD / User's Choice Windows CD (CMS Software)(1993).iso / drvrs / xgav210.zip / XGAPCDOS / AFIDATA.H next >
Text File  |  1993-07-21  |  69KB  |  995 lines
  1. /* (C) Copyright IBM Corporation 1986,1987,1988,1989,1990 ********************/
  2. /*                                                                           */
  3. /*              Program:      Definitions and declarations relevant to the   */
  4. /*                            Adapter Interface                              */
  5. /*                                                                           */
  6. /*              File/module:  AFIDATA.H                                      */
  7. /*                                                                           */
  8. /*                            AI Base Function                               */
  9. /*                            + Extended Function Sets (1) and (2)           */
  10. /*                                                                           */
  11. /*****************************************************************************/
  12.  
  13. #define HLINE_DATA(S) struct { word length; coord_pr coords[S]; }
  14. /* usage: HLINE_DATA(size) will give the following structure            */
  15. /*                                                                      */
  16. /*  struct                                                              */
  17. /*  {                                                                   */
  18. /*  word length;                                                        */
  19. /*  coord_pr coords[size];                                              */
  20. /*  }                                                                   */
  21. /*                                                                      */
  22.  
  23. #define HCLINE_DATA(S) struct { word length; coord_pr coords[S]; }
  24. /* usage: HCLINE_DATA(size) will give the following structure           */
  25. /*                                                                      */
  26. /*  struct                                                              */
  27. /*  {                                                                   */
  28. /*  word length;                                                        */
  29. /*  coord_pr coords[size];                                              */
  30. /*  }                                                                   */
  31. /*                                                                      */
  32.  
  33. #define HRLINE_DATA(S) struct { word length; coord_pr coord1; rcoord_pr rcoords[S]; }
  34. /* usage: HRLINE_DATA(size) will give the following structure           */
  35. /*                                                                      */
  36. /*  struct                                                              */
  37. /*  {                                                                   */
  38. /*  word length;                                                        */
  39. /*  coord_pr coord1;                                                    */
  40. /*  rcoord_pr rcoords[size];                                            */
  41. /*  }                                                                   */
  42. /*                                                                      */
  43.  
  44. #define HCRLINE_DATA(S) struct { word length; rcoord_pr rcoords[S]; }
  45. /* usage: HCRLINE_DATA(size) will give the following structure          */
  46. /*                                                                      */
  47. /*  struct                                                              */
  48. /*  {                                                                   */
  49. /*  word length;                                                        */
  50. /*  rcoord_pr rcoords[size];                                            */
  51. /*  }                                                                   */
  52. /*                                                                      */
  53.  
  54. #define HSCP_DATA struct { word length; coord_pr coord1; }
  55. /* usage: HSCP_DATA will give the following structure                   */
  56. /*                                                                      */
  57. /*  struct                                                              */
  58. /*  {                                                                   */
  59. /*  word length;                                                        */
  60. /*  coord_pr coord1;                                                    */
  61. /*  }                                                                   */
  62. /*                                                                      */
  63.  
  64. /* There is no HBAR data                                                */
  65. /*                                                                      */
  66.  
  67. #define HEAR_DATA struct { word length; byte flags; }
  68. /* usage: HEAR_DATA will give the following structure                   */
  69. /*                                                                      */
  70. /*  struct                                                              */
  71. /*  {                                                                   */
  72. /*  word length;                                                        */
  73. /*  byte flags;                                                         */
  74. /*  }                                                                   */
  75. /*                                                                      */
  76.  
  77. #define HSCOL_DATA struct { word length; long index; }
  78. /* usage: HSCOL_DATA will give the following structure                  */
  79. /*                                                                      */
  80. /*  struct                                                              */
  81. /*  {                                                                   */
  82. /*  word length;                                                        */
  83. /*  long index;                                                         */
  84. /*  }                                                                   */
  85. /*                                                                      */
  86.  
  87. #define HOPEN_DATA struct { word length; byte oflags,mode,iflags; }
  88. /* usage: HOPEN_DATA will give the following structure                  */
  89. /*                                                                      */
  90. /*  struct                                                              */
  91. /*  {                                                                   */
  92. /*  word length;                                                        */
  93. /*  byte oflags,                                                        */
  94. /*       mode,                                                          */
  95. /*       iflags;                                                        */
  96. /*  }                                                                   */
  97. /*                                                                      */
  98. /*                                                                      */
  99.  
  100. #define HSMX_DATA struct { word length; byte foremix; byte backmix; }
  101. /* usage: HSMX_DATA will give the following structure                   */
  102. /*                                                                      */
  103. /*  struct                                                              */
  104. /*  {                                                                   */
  105. /*  word length;                                                        */
  106. /*  byte foremix;                                                       */
  107. /*  byte backmix;                                                       */
  108. /*  }                                                                   */
  109. /*                                                                      */
  110. #define MIX_NOC       0x00      /* No change to mix     */
  111. #define MIX_OR        0x01      /* OR                   */
  112. #define MIX_OVER      0x02      /* Overpaint             */
  113. #define MIX_XOR       0x04      /* Exclusive OR          */
  114. #define MIX_LEAVE     0x05      /* Leave alone           */
  115. #define MIX_ADD       0x08      /* Add colour to screen  */
  116. #define MIX_SUB       0x09      /* screen - colour      */
  117. #define MIX_MEAN      0x0B      /* average of screen & colour   */
  118.  
  119. #define HSBCOL_DATA struct { word length; long index; }
  120. /* usage: HSBCOL_DATA will give the following structure                 */
  121. /*                                                                      */
  122. /*  struct                                                              */
  123. /*  {                                                                   */
  124. /*  word length;                                                        */
  125. /*  long index;                                                         */
  126. /*  }                                                                   */
  127. /*                                                                      */
  128.  
  129. #define HSLT_DATA struct { word length; byte index, reserved; byte far *def; }
  130. /* usage: HSLT_DATA will give the following structure                   */
  131. /*                                                                      */
  132. /*  struct                                                              */
  133. /*  {                                                                   */
  134. /*  word length;                                                        */
  135. /*  byte index;                                                         */
  136. /*  byte reserved;                                                      */
  137. /*  byte far *def;                                                      */
  138. /*  }                                                                   */
  139. /*                                                                      */
  140.  
  141. #define HSLW_DATA struct { word length; byte index; }
  142. /* usage: HSLW_DATA will give the following structure                   */
  143. /*                                                                      */
  144. /*  struct                                                              */
  145. /*  {                                                                   */
  146. /*  word length;                                                        */
  147. /*  byte index;                                                         */
  148. /*  }                                                                   */
  149. /*                                                                      */
  150.  
  151. /* There is no HEGS data                                                */
  152. /*                                                                      */
  153.  
  154.  
  155. #define HSGQ_DATA struct { word length; word index; }
  156. /* usage: HSGQ_DATA will give the following structure                   */
  157. /*                                                                      */
  158. /*  struct                                                              */
  159. /*  {                                                                   */
  160. /*  word length;                                                        */
  161. /*  word index;                                                         */
  162. /*  }                                                                   */
  163. /*                                                                      */
  164.  
  165. #define HSCMP_DATA struct { word length; long col; byte function; }
  166. /* usage: HSCMP_DATA will give the following structure                  */
  167. /*                                                                      */
  168. /*  struct                                                              */
  169. /*  {                                                                   */
  170. /*  word length;                                                        */
  171. /*  long col;                                                           */
  172. /*  byte function;                                                      */
  173. /*  }                                                                   */
  174. /*                                                                      */
  175.  
  176. #define HINT_DATA struct { word length; long eventid; }
  177. /* usage: HINT_DATA will give the following structure                   */
  178. /*                                                                      */
  179. /*  struct                                                              */
  180. /*  {                                                                   */
  181. /*  word length;                                                        */
  182. /*  long eventid;                                                       */
  183. /*  }                                                                   */
  184. /*                                                                      */
  185.  
  186. #define HSPATTO_DATA struct { word length; coord_pr coord1; }
  187. /* usage: HSPATTO_DATA will give the following structure                */
  188. /*                                                                      */
  189. /*  struct                                                              */
  190. /*  {                                                                   */
  191. /*  word length,                                                        */
  192. /*  coord_pr coord1;                                                    */
  193. /*  }                                                                   */
  194. /*                                                                      */
  195.  
  196. #define HSPATT_DATA struct { word length; byte width,height,flags,reserved; word img_length; byte far *image, far *colour; }
  197. /* usage: HSPATT_DATA will give the following structure                 */
  198. /*                                                                      */
  199. /*  struct                                                              */
  200. /*  {                                                                   */
  201. /*  word length;                                                        */
  202. /*  byte width,                                                         */
  203. /*       height,                                                        */
  204. /*       flags,                                                         */
  205. /*       reserved;                                                      */
  206. /*  word img_length;                                                    */
  207. /*  byte far *image,                                                    */
  208. /*       far *colour;                                                   */
  209. /*  }                                                                   */
  210. /*                                                                      */
  211.  
  212. #define HLDPAL_DATA struct { word length; byte pal_id,res1;word first,count;byte far *address; }
  213. /* usage: HLDPAL_DATA will give the following structure                 */
  214. /*                                                                      */
  215. /*  struct                                                              */
  216. /*  {                                                                   */
  217. /*  word length;                                                        */
  218. /*  byte pal_id,                                                        */
  219. /*       res1;                                                          */
  220. /*  word first,                                                         */
  221. /*       count;                                                         */
  222. /*  byte far *address;                                                  */
  223. /*  }                                                                   */
  224. /*                                                                      */
  225.  
  226. #define HSHS_DATA struct { word length;word l,r,b,t;byte far *address;byte flags;}
  227. /* usage: HSHS_DATA will give the following structure                   */
  228. /*                                                                      */
  229. /*  struct                                                              */
  230. /*  {                                                                   */
  231. /*  word length;                                                        */
  232. /*  word l,                                                             */
  233. /*       r,                                                             */
  234. /*       b,                                                             */
  235. /*       t;                                                             */
  236. /*  byte far *address;                                                  */
  237. /*  byte flags;                                                         */
  238. /*  }                                                                   */
  239. /*                                                                      */
  240.  
  241. #define HBBW_DATA struct { word length,format,width,height; coord_pr coord; word l,t,w,h; }
  242. /* usage: HBBW_DATA will give the following structure                   */
  243. /*                                                                      */
  244. /*  struct                                                              */
  245. /*  {                                                                   */
  246. /*  word length,                                                        */
  247. /*      format,                                                         */
  248. /*      width,                                                          */
  249. /*      height,                                                         */
  250. /*  coord_pr coord;                                                     */
  251. /*  word l,                                                             */
  252. /*       t,                                                             */
  253. /*       w,                                                             */
  254. /*       h;                                                             */
  255. /*  }                                                                   */
  256. /*                                                                      */
  257.  
  258. #define HCBBW_DATA struct { word length,format,width,height,l,t,w,h; }
  259. /* usage: HCBBW_DATA will give the following structure                  */
  260. /*                                                                      */
  261. /*  struct                                                              */
  262. /*  {                                                                   */
  263. /*  word length,                                                        */
  264. /*      format,                                                         */
  265. /*      width,                                                          */
  266. /*      height,                                                         */
  267. /*      l,                                                              */
  268. /*      t,                                                              */
  269. /*      w,                                                              */
  270. /*      h;                                                              */
  271. /*  }                                                                   */
  272. /*                                                                      */
  273.  
  274. #define HBBR_DATA struct { word length,format,width,height; byte plane,reserved; coord_pr coord; word l,t,w,h;}
  275. /* usage: HBBR_DATA will give the following structure                   */
  276. /*                                                                      */
  277. /*  struct                                                              */
  278. /*  {                                                                   */
  279. /*  word length,                                                        */
  280. /*      format,                                                         */
  281. /*      width,                                                          */
  282. /*      height,                                                         */
  283. /*  byte plane,                                                         */
  284. /*       reserved;                                                      */
  285. /*  coord_pr coord;                                                     */
  286. /*  word l,                                                             */
  287. /*       t,                                                             */
  288. /*       w,                                                             */
  289. /*       h,                                                             */
  290. /*  }                                                                   */
  291. /*                                                                      */
  292.  
  293. #define HBBCHN_DATA struct { word length; byte far *address; word len; }
  294. /* usage: HBBCHN_DATA will give the following structure                 */
  295. /*                                                                      */
  296. /*  struct                                                              */
  297. /*  {                                                                   */
  298. /*  word length;                                                        */
  299. /*  byte far *address;                                                  */
  300. /*  word len;                                                           */
  301. /*  }                                                                   */
  302. /*                                                                      */
  303.  
  304. #define HBBC_DATA struct { word length,format,width,height; byte plane,reserved; coord_pr source,dest; }
  305. /* usage: HBBC_DATA will give the following structure                   */
  306. /*                                                                      */
  307. /*  struct                                                              */
  308. /*  {                                                                   */
  309. /*  word length,                                                        */
  310. /*      format,                                                         */
  311. /*      width,                                                          */
  312. /*      height,                                                         */
  313. /*  byte plane,                                                         */
  314. /*       reserved;                                                      */
  315. /*  coord_pr source,                                                    */
  316. /*           dest;                                                      */
  317. /*  }                                                                   */
  318. /*                                                                      */
  319.  
  320. #define HSCOORD_DATA struct { word length; byte acformat,rcformat,ndimens; }
  321. /* usage: HSCOORD_DATA will give the following structure                */
  322. /*                                                                      */
  323. /*  struct                                                              */
  324. /*  {                                                                   */
  325. /*  word length;                                                        */
  326. /*  byte acformat,                                                      */
  327. /*       rcformat,                                                      */
  328. /*       ndimens;                                                       */
  329. /*  }                                                                   */
  330. /*                                                                      */
  331.  
  332. #define HQCOORD_DATA struct { word length; byte acformat,rcformat,ndimens,result; }
  333. /* usage: HQCOORD_DATA will give the following structure                */
  334. /*                                                                      */
  335. /*  struct                                                              */
  336. /*  {                                                                   */
  337. /*  word length;                                                        */
  338. /*  byte acformat,                                                      */
  339. /*       rcformat,                                                      */
  340. /*       ndimens,                                                       */
  341. /*       result;                                                        */
  342. /*  }                                                                   */
  343. /*                                                                      */
  344.  
  345. #define HSMODE_DATA struct { word length; byte scformat,flags; }
  346. /* usage: HSMODE_DATA will give the following structure                 */
  347. /*                                                                      */
  348. /*  struct                                                              */
  349. /*  {                                                                   */
  350. /*  word length;                                                        */
  351. /*  byte scformat,                                                      */
  352. /*       flags;                                                         */
  353. /*  }                                                                   */
  354. /*                                                                      */
  355.  
  356. #define HQMODE_DATA struct { word length; byte mode; byte clvl[2]; byte atype,dtype,ac_w,ac_h,nplanes;word width,height,h_pitch,v_pitch;byte moco,n_i_lvls,areafp,vga; }
  357. /* usage: HQMODE_DATA will give the following structure                 */
  358. /*                                                                      */
  359. /*  struct                                                              */
  360. /*  {                                                                   */
  361. /*  word length;                                                        */
  362. /*  byte mode;                                                          */
  363. /*  byte clvl[2];                                                       */
  364. /*  byte atype,                                                         */
  365. /*       dtype,                                                         */
  366. /*       ac_w,                                                          */
  367. /*       ac_h,                                                          */
  368. /*       nplanes;                                                       */
  369. /*  word width,                                                         */
  370. /*       height,                                                        */
  371. /*       h_pitch,                                                       */
  372. /*       v_pitch;                                                       */
  373. /*  byte moco,                                                          */
  374. /*       n_i_lvls,                                                      */
  375. /*       areafp,                                                        */
  376. /*       vga;                                                           */
  377. /*  }                                                                   */
  378. /*                                                                      */
  379.  
  380. #define HQMODES_DATA struct { word length; byte atype,modes[32]; }
  381. /* usage: HQMODES_DATA will give the following structure                */
  382. /*                                                                      */
  383. /*  struct                                                              */
  384. /*  {                                                                   */
  385. /*  word length;                                                        */
  386. /*  byte atype,                                                         */
  387. /*       modes[32];                                                     */
  388. /*  }                                                                   */
  389. /*                                                                      */
  390.  
  391. #define HQDPS_DATA struct { word length; word size, stack, palbufsize; longword vramsize,areafpsize; }
  392. /* usage: HQDPS_DATA will give the following structure                  */
  393. /*                                                                      */
  394. /*  struct                                                              */
  395. /*  {                                                                   */
  396. /*  word length;                                                        */
  397. /*  word size,                                                          */
  398. /*       stack,                                                         */
  399. /*       palbufsize;                                                    */
  400. /*  longword vramsize,                                                  */
  401. /*           areafpsize,                                                */
  402. /*  }                                                                   */
  403. /*                                                                      */
  404.  
  405. #define HRECT_DATA struct { word length; coord_pr coord; word width,height; }
  406. /* usage: HRECT_DATA will give the following structure                  */
  407. /*                                                                      */
  408. /*  struct                                                              */
  409. /*  {                                                                   */
  410. /*  word length;                                                        */
  411. /*  coord_pr coord;                                                     */
  412. /*  word width,                                                         */
  413. /*       height;                                                        */
  414. /*  }                                                                   */
  415. /*                                                                      */
  416.  
  417. #define HRECTS_DATA(S) struct { word length; rect_def rect[S]; }
  418. /* usage: HRECTS_DATA(size) will give the following structure           */
  419. /*                                                                      */
  420. /*  struct                                                              */
  421. /*  {                                                                   */
  422. /*  word length;                                                        */
  423. /*  rect_def rect[size];                                                */
  424. /*  }                                                                   */
  425. /*                                                                      */
  426.  
  427. #define HSBP_DATA struct { word length; longword grupdate, alupdate, display; byte flags, reserved; longword green_msk, red_msk, blue_msk; }
  428. /* usage: HSBP_DATA will give the following structure                   */
  429. /*                                                                      */
  430. /*  struct                                                              */
  431. /*  {                                                                   */
  432. /*  word length;                                                        */
  433. /*  longword grupdate,                                                  */
  434. /*           alupdate,                                                  */
  435. /*           display;                                                   */
  436. /*  byte flags,                                                         */
  437. /*       reserved;                                                      */
  438. /*  longword green_msk,                                                 */
  439. /*           red_msk,                                                   */
  440. /*           blue_msk;                                                  */
  441. /*  }                                                                   */
  442. /*                                                                      */
  443.  
  444. #define HCLOSE_DATA struct { word length; word flags; }
  445. /* usage: HCLOSE_DATA will give the following structure                 */
  446. /*                                                                      */
  447. /*  struct                                                              */
  448. /*  {                                                                   */
  449. /*  word length;                                                        */
  450. /*  word flags;                                                         */
  451. /*  }                                                                   */
  452. /*                                                                      */
  453. /*                                                                      */
  454.  
  455.  
  456. /* There is no HESC data                                                */
  457. /*                                                                      */
  458.  
  459. #define HXLATE_DATA struct { word length; longword table[8]; }
  460. /* usage: HXLATE_DATA will give the following structure                 */
  461. /*                                                                      */
  462. /*  struct                                                              */
  463. /*  {                                                                   */
  464. /*  word length;                                                        */
  465. /*  longword table[8];                                                  */
  466. /*  }                                                                   */
  467. /*                                                                      */
  468.  
  469. struct CharSetDef   /* Character Set Definition block                   */
  470. {
  471.   byte reserve1;        /* reserved                                     */
  472.   byte csettype;        /* Char set type  0 - image/triplane image      */
  473.                         /*                3 - short stroke vector       */
  474.   long reserve2;        /* reserved                                     */
  475.   byte reserve3;        /* reserved                                     */
  476.   byte cellwidth;       /* character cell width (pels)                  */
  477.   byte cellheight;      /* character cell height (pels)                 */
  478.   byte reserve4;        /* reserved                                     */
  479.   word cellnbytes;      /* no. bytes per cell definition (ceil(cx*cy/8))*/
  480.   word flags;           /* Flags as follows                             */
  481. #define MULTIPLANE 0x4000       /* single or multi plane                */
  482. #define PROPSPACE  0x2000       /* single or multi plane                */
  483.   word far *indextbl;   /* address of index table                       */
  484.   byte far *enveltbl;   /* address of envelope table                    */
  485.   byte cdpt1st;         /* initial code point                           */
  486.   byte cdptlast;        /* final code point                             */
  487.   byte far *chardef1;   /* address of character definition 1            */
  488.   word reserve5;        /* reserved                                     */
  489.   byte far *chardef2;   /* address of character definition 2            */
  490.   word reserve6;        /* reserved                                     */
  491.   byte far *chardef3;   /* address of character definition 3            */
  492. };
  493.  
  494. #define HSCS_DATA struct { word length; struct CharSetDef far *address; }
  495. /* usage: HSCS_DATA will give the following structure                   */
  496. /*                                                                      */
  497. /*  struct                                                              */
  498. /*  {                                                                   */
  499. /*  word length;                                                        */
  500. /*  struct CharSetDef far *address;                                     */
  501. /*  }                                                                   */
  502. /*                                                                      */
  503.  
  504. #define HCHST_DATA(L) struct { word length; coord_pr coord; char string[L]; }
  505. /* usage: HCHST_DATA will give the following structure                  */
  506. /*                                                                      */
  507. /*  struct                                                              */
  508. /*  {                                                                   */
  509. /*  word length;                                                        */
  510. /*  coord_pr coord;                                                     */
  511. /*  char string[L];                                                     */
  512. /*  }                                                                   */
  513. /*                                                                      */
  514.  
  515. #define HCCHST_DATA(L) struct { word length; char string[L]; }
  516. /* usage: HCCHST_DATA will give the following structure                 */
  517. /*                                                                      */
  518. /*  struct                                                              */
  519. /*  {                                                                   */
  520. /*  word length;                                                        */
  521. /*  char string[L];                                                     */
  522. /*  }                                                                   */
  523. /*                                                                      */
  524.  
  525. #define ABLKMFI_DATA struct { word length; byte colm,row,across,down; byte far *chars; byte width; }
  526. /* usage: ABLKMFI_DATA will give the following structure                */
  527. /*                                                                      */
  528. /* struct                                                               */
  529. /* {                                                                    */
  530. /* word length;                                                         */
  531. /* byte colm,                                                           */
  532. /*      row,                                                            */
  533. /*      across,                                                         */
  534. /*      down;                                                           */
  535. /* byte far *chars;                                                     */
  536. /* byte width;                                                          */
  537. /* }                                                                    */
  538. /*                                                                      */
  539.  
  540. #define ABLKCGA_DATA struct { word length; byte colm,row,across,down; byte far *chars; byte width,hilite; }
  541. /* usage: ABLKCGA_DATA will give the following structure                */
  542. /*                                                                      */
  543. /* struct                                                               */
  544. /* {                                                                    */
  545. /* word length;                                                         */
  546. /* byte colm,                                                           */
  547. /*      row,                                                            */
  548. /*      across,                                                         */
  549. /*      down;                                                           */
  550. /* byte far *chars;                                                     */
  551. /* byte width,                                                          */
  552. /*      hilite;                                                         */
  553. /* }                                                                    */
  554. /*                                                                      */
  555.  
  556. #define AERASE_DATA struct { word length; byte colm,row,across,down,colour; }
  557. /* usage: AERASE_DATA will give the following structure                 */
  558. /*                                                                      */
  559. /* struct                                                               */
  560. /* {                                                                    */
  561. /* word length;                                                         */
  562. /* byte colm,                                                           */
  563. /*      row,                                                            */
  564. /*      across,                                                         */
  565. /*      down,                                                           */
  566. /*      colour;                                                         */
  567. /* }                                                                    */
  568. /*                                                                      */
  569.  
  570. #define ASCROLL_DATA struct { word length; byte sor_colm,sor_row,across,down,des_colm,des_row; }
  571. /* usage: ASCROLL_DATA will give the following structure                */
  572. /*                                                                      */
  573. /* struct                                                               */
  574. /* {                                                                    */
  575. /* word length;                                                         */
  576. /* byte sor_colm,                                                       */
  577. /*      sor_row,                                                        */
  578. /*      across,                                                         */
  579. /*      down,                                                           */
  580. /*      des_colm;                                                       */
  581. /*      des_row;                                                        */
  582. /* }                                                                    */
  583. /*                                                                      */
  584.  
  585. #define ACURSOR_DATA struct { word length; byte colm,row; }
  586. /* usage: ACURSOR_DATA will give the following structure                */
  587. /*                                                                      */
  588. /* struct                                                               */
  589. /* {                                                                    */
  590. /* word length;                                                         */
  591. /* byte colm,                                                           */
  592. /*      row;                                                            */
  593. /* }                                                                    */
  594. /*                                                                      */
  595.  
  596. #define ASCUR_DATA struct { word length; byte start,stop,attr; }
  597. /* usage: ASCUR_DATA will give the following structure                  */
  598. /*                                                                      */
  599. /* struct                                                               */
  600. /* {                                                                    */
  601. /* word length;                                                         */
  602. /* byte start,                                                          */
  603. /*      stop,                                                           */
  604. /*      attr;                                                           */
  605. /* }                                                                    */
  606. /*                                                                      */
  607.  
  608. #define ASFONT_DATA struct { word length; byte font,res; struct CharSetDef far *address; }
  609. /* usage: ASFONT_DATA will give the following structure                 */
  610. /*                                                                      */
  611. /* struct                                                               */
  612. /* {                                                                    */
  613. /* word length;                                                         */
  614. /* byte font,                                                           */
  615. /*      res;                                                            */
  616. /* struct CharSetDef far *address;                                      */
  617. /* }                                                                    */
  618. /*                                                                      */
  619.  
  620. #define AXLATE_DATA struct { word length; longword foretable[16],backtable[16]; }
  621. /* usage: AXLATE_DATA will give the following structure                 */
  622. /*                                                                      */
  623. /* struct                                                               */
  624. /* {                                                                    */
  625. /* word length;                                                         */
  626. /* longword foretable[16],                                              */
  627. /*          backtable[16];                                              */
  628. /* }                                                                    */
  629. /*                                                                      */
  630.  
  631. #define HINIT_DATA struct { word length; word segment; }
  632. /* usage: HINIT_DATA will give the following structure                  */
  633. /*                                                                      */
  634. /*  struct                                                              */
  635. /*  {                                                                   */
  636. /*  word length;                                                        */
  637. /*  word segment;                                                       */
  638. /*  }                                                                   */
  639. /*                                                                      */
  640.  
  641. #define HSYNC_DATA struct { word length; word segment; }
  642. /* usage: HSYNC_DATA will give the following structure                  */
  643. /*                                                                      */
  644. /*  struct                                                              */
  645. /*  {                                                                   */
  646. /*  word length;                                                        */
  647. /*  word segment;                                                       */
  648. /*  }                                                                   */
  649. /*                                                                      */
  650.  
  651. #define HMRK_DATA(S) struct { word length; coord_pr coords[S];}
  652. /* usage: HMRK_DATA will give the following structure                   */
  653. /*                                                                      */
  654. /* struct                                                               */
  655. /* {                                                                    */
  656. /* word length;                                                         */
  657. /* coord_pr coords[S]                                                   */
  658. /* }                                                                    */
  659. /*                                                                      */
  660.  
  661. #define HCMRK_DATA(S) struct { word length; coord_pr coords[S];}
  662. /* usage: HCMRK_DATA will give the following structure                  */
  663. /*                                                                      */
  664. /* struct                                                               */
  665. /* {                                                                    */
  666. /* word length;                                                         */
  667. /* coord_pr coords[S]                                                   */
  668. /* }                                                                    */
  669. /*                                                                      */
  670.  
  671. #define HSMARK_DATA struct {word length; byte width, height, flags, res; word imlen; byte far *image; byte far *colour; }
  672. /* usage: HSMARK_DATA will give the following structure                 */
  673. /*                                                                      */
  674. /* struct                                                               */
  675. /* {                                                                    */
  676. /* word length;                                                         */
  677. /* byte width,                                                          */
  678. /*      height,                                                         */
  679. /*      flags,                                                          */
  680. /*      res;                                                            */
  681. /* word imlen;                                                          */
  682. /* byte far *image;                                                     */
  683. /* byte far *colour;                                                    */
  684. /* }                                                                    */
  685. /*                                                                      */
  686.  
  687. #define HSLPC_DATA struct { word length; word count; }
  688. /* usage: HSLPC_DATA will give the following structure                  */
  689. /*                                                                      */
  690. /*  struct                                                              */
  691. /*  {                                                                   */
  692. /*  word length;                                                        */
  693. /*  word count;                                                         */
  694. /*  }                                                                   */
  695. /*                                                                      */
  696.  
  697. #define HRLPC_DATA struct { word length; word count; }
  698. /* usage: HRLPC_DATA will give the following structure                  */
  699. /*                                                                      */
  700. /*  struct                                                              */
  701. /*  {                                                                   */
  702. /*  word length;                                                        */
  703. /*  word count;                                                         */
  704. /*  }                                                                   */
  705. /*                                                                      */
  706.  
  707. #define HQCP_DATA struct { word length; coord_pr coord1; }
  708. /* usage: HQCP_DATA will give the following structure                   */
  709. /*                                                                      */
  710. /*  struct                                                              */
  711. /*  {                                                                   */
  712. /*  word length;                                                        */
  713. /*  coord_pr coord1;                                                    */
  714. /*  }                                                                   */
  715. /*                                                                      */
  716.  
  717. #define HQDFPAL_DATA struct {word length; long table[16]; }
  718. /* usage: HQDFPAL_DATA will give the following structure                */
  719. /*                                                                      */
  720. /* struct                                                               */
  721. /* {                                                                    */
  722. /* word length;                                                         */
  723. /* long table[16];                                                      */
  724. /* }                                                                    */
  725. /*                                                                      */
  726.  
  727. #define HSPAL_DATA struct { word length; byte paldata[769]; }
  728. /* usage: HSPAL_DATA will give the following structure                  */
  729. /*                                                                      */
  730. /*  struct                                                              */
  731. /*  {                                                                   */
  732. /*  word length;                                                        */
  733. /*  byte paldata[769];                                                  */
  734. /*  }                                                                   */
  735. /*                                                                      */
  736.  
  737. #define HRPAL_DATA HSPAL_DATA
  738. /* usage: HRPAL uses an HSPAL data block                                */
  739. /*                                                                      */
  740.  
  741. #define HSFPAL_DATA struct { word length; word format; byte paldata[769]; }
  742. /* usage: HSFPAL_DATA will give the following structure                 */
  743. /*                                                                      */
  744. /*  struct                                                              */
  745. /*  {                                                                   */
  746. /*  word length;                                                        */
  747. /*  word format;                                                        */
  748. /*  byte paldata[769];                                                  */
  749. /*  }                                                                   */
  750. /*                                                                      */
  751.  
  752. #define HRFPAL_DATA HSFPAL_DATA
  753. /* usage: HRFPAL uses an HSFPAL data block                              */
  754. /*                                                                      */
  755.  
  756. #define HSAFP_DATA struct { word length; byte far *address; byte flags; }
  757. /* usage: HSAFP will give the following structure                       */
  758. /*                                                                      */
  759. /*  struct                                                              */
  760. /*  {                                                                   */
  761. /*  word length;                                                        */
  762. /*  byte far *address;                                                  */
  763. /*  byte flags;                                                         */
  764. /*  }                                                                   */
  765. /*                                                                      */
  766.  
  767. #define ASCELL_DATA struct { word length; byte width,height; }
  768. /* usage: ASCELL will give the following structure                      */
  769. /*                                                                      */
  770. /*  struct                                                              */
  771. /*  {                                                                   */
  772. /*  word length;                                                        */
  773. /*  byte width,                                                         */
  774. /*       height;                                                        */
  775. /*  }                                                                   */
  776. /*                                                                      */
  777.  
  778. #define ASGO_DATA struct { word length; coord_pr coord; }
  779. /* usage: ASGO_DATA will give the following structure                   */
  780. /*                                                                      */
  781. /*  struct                                                              */
  782. /*  {                                                                   */
  783. /*  word length;                                                        */
  784. /*  coord_pr coord;                                                     */
  785. /*  }                                                                   */
  786. /*                                                                      */
  787.  
  788. #define HDLINE_DATA(S) struct { word length; dcoord  dcoords[S]; }
  789. /* usage: HDLINE_DATA(size) will give the following structure           */
  790. /*                                                                      */
  791. /*  struct                                                              */
  792. /*  {                                                                   */
  793. /*      word    length;                                                 */
  794. /*      dcoord  dcoords[size];                                          */
  795. /*  }                                                                   */
  796. /*                                                                      */
  797.  
  798. #define HPEL_DATA(S) struct { word length; pel_pr coord[S];}
  799. /* usage: HPEL_DATA(size) will give the following structure             */
  800. /*                                                                      */
  801. /*  struct                                                              */
  802. /*  {                                                                   */
  803. /*  word length;                                                        */
  804. /*  pel_pr coord[size];                                                 */
  805. /*  }                                                                   */
  806. /*                                                                      */
  807.  
  808. #define HRPEL_DATA struct { word length; byte far *address; coord_pr coord; word pel_count; }
  809. /* usage: HRPEL_DATA will give the following structure                  */
  810. /*                                                                      */
  811. /*  struct                                                              */
  812. /*  {                                                                   */
  813. /*  word length;                                                        */
  814. /*  byte far *address;                                                  */
  815. /*  coord_pr coord;                                                     */
  816. /*  word pel_count;                                                     */
  817. /*  }                                                                   */
  818. /*                                                                      */
  819.  
  820. #define HPSTEP_DATA struct { word length; coord_pr coord; byte far *def_address,*src_address; }
  821. /* usage: HPSTEP_DATA will give the following structure                 */
  822. /*                                                                      */
  823. /*  struct                                                              */
  824. /*  {                                                                   */
  825. /*  word length;                                                        */
  826. /*  coord_pr coord;                                                     */
  827. /*  byte far *def_address,                                              */
  828. /*           *src_address;                                              */
  829. /*  }                                                                   */
  830. /*                                                                      */
  831.  
  832. #define HCPSTEP_DATA struct { word length; byte far *def_address,*src_address; }
  833. /* usage: HCPSTEP_DATA will give the following structure                */
  834. /*                                                                      */
  835. /*  struct                                                              */
  836. /*  {                                                                   */
  837. /*  word length;                                                        */
  838. /*  byte far *def_address,                                              */
  839. /*           *src_address;                                              */
  840. /*  }                                                                   */
  841. /*                                                                      */
  842.  
  843. #define HRSTEP_DATA struct { word length; coord_pr coord; byte far *def_address,*tgt_address; }
  844. /* usage: HRSTEP_DATA will give the following structure                 */
  845. /*                                                                      */
  846. /*  struct                                                              */
  847. /*  {                                                                   */
  848. /*  word length;                                                        */
  849. /*  coord_pr coord;                                                     */
  850. /*  byte far *def_address,                                              */
  851. /*           *tgt_address;                                              */
  852. /*  }                                                                   */
  853. /*                                                                      */
  854.  
  855. #define HSBMAP_DATA struct { word length; byte flags, format; byte far *bmap_addr; word width, height; }
  856. /* usage: HSBMAP_DATA will give the following structure                 */
  857. /*                                                                      */
  858. /*  struct                                                              */
  859. /*  {                                                                   */
  860. /*  word length;                                                        */
  861. /*  byte flags,                                                         */
  862. /*       format;                                                        */
  863. /*  byte far *bmap_addr;                                                */
  864. /*  word width,                                                         */
  865. /*       height;                                                        */
  866. /*  }                                                                   */
  867. /*                                                                      */
  868.  
  869. #define HQBMAP_DATA struct { word length; byte flags, format; byte far *bmap_addr; word width, height; coord_pr coord; word wind_width, wind_height;}
  870. /* usage: HQBMAP_DATA will give the following structure                 */
  871. /*                                                                      */
  872. /*  struct                                                              */
  873. /*  {                                                                   */
  874. /*  word length;                                                        */
  875. /*  byte flags,                                                         */
  876. /*       format;                                                        */
  877. /*  byte far *bmap_addr;                                                */
  878. /*  word width,                                                         */
  879. /*       height;                                                        */
  880. /*  coord_pr coord;                                                     */
  881. /*  word wind_width,                                                    */
  882. /*       wind_height;                                                   */
  883. /*  }                                                                   */
  884. /*                                                                      */
  885.  
  886. #define HBMC_DATA struct {word length;word flags,blk_width,blk_height; byte dst_format,reserved1;byte far *dst_addr;word dst_width,dst_height;coord_pr dst_coord; byte src_format,reserved2;byte far *src_addr;word src_width,src_height;coord_pr src_coord;\
  887. byte pat_format,reserved3;byte far *pat_addr;word pat_width,pat_height;coord_pr pat_coord;}
  888. /* usage: HBMC_DATA will give the following structure                   */
  889. /*                                                                      */
  890. /*  struct                                                              */
  891. /*  {                                                                   */
  892. /*  word length;                                                        */
  893. /*  word flags,                                                         */
  894. /*       blk_width,                                                     */
  895. /*       blk_height;                                                    */
  896. /*                                                                      */
  897. /*  byte      dst_format,                                               */
  898. /*            reserved1;                                                */
  899. /*  byte far *dst_addr;                                                 */
  900. /*  word      dst_width,                                                */
  901. /*            dst_height;                                               */
  902. /*  coord_pr  dst_coord;                                                */
  903. /*                                                                      */
  904. /*  byte      src_format,                                               */
  905. /*            reserved2;                                                */
  906. /*  byte far *src_addr;                                                 */
  907. /*  word      src_width,                                                */
  908. /*            src_height;                                               */
  909. /*  coord_pr  src_coord;                                                */
  910. /*                                                                      */
  911. /*  byte      pat_format,                                               */
  912. /*            reserved3;                                                */
  913. /*  byte far *pat_addr;                                                 */
  914. /*  word      pat_width,                                                */
  915. /*            pat_height;                                               */
  916. /*  coord_pr  pat_coord;                                                */
  917. /*                                                                      */
  918. /*  }                                                                   */
  919.  
  920. #define HSPRITE_DATA struct { word length; coord_pr coord; }
  921. /* usage: HSPRITE will give the following structure                     */
  922. /*                                                                      */
  923. /*  struct                                                              */
  924. /*  {                                                                   */
  925. /*  word length;                                                        */
  926. /*  coord_pr coord;                                                     */
  927. /*  }                                                                   */
  928. /*                                                                      */
  929.  
  930. #define HSSPRITE_DATA struct { word length; byte flags,res,hotx,hoty; byte far *image;word width,height;\
  931.                                word col1_green, col1_red, col1_blue, col2_green, col2_red, col2_blue; }
  932. /* usage: HSSPRITE_DATA will give the following structure               */
  933. /*                                                                      */
  934. /* struct                                                               */
  935. /* {                                                                    */
  936. /* word length;                                                         */
  937. /* byte flags,                                                          */
  938. /*      res,                                                            */
  939. /*      hotx,                                                           */
  940. /*      hoty;                                                           */
  941. /* byte far *image;                                                     */
  942. /* word width,                                                          */
  943. /*      height;                                                         */
  944. /* word col1_green,                                                     */
  945. /*      col1_red,                                                       */
  946. /*      col1_blue,                                                      */
  947. /*      col2_green,                                                     */
  948. /*      col2_red,                                                       */
  949. /*      col2_blue;                                                      */
  950. /* }                                                                    */
  951.  
  952. #define HSDW_DATA struct { word length; coord_pr coord; word width,height;}
  953. /* usage: HSDW_DATA will give the following structure                   */
  954. /*                                                                      */
  955. /*  struct                                                              */
  956. /*  {                                                                   */
  957. /*  word length;                                                        */
  958. /*  coord_pr coord;                                                     */
  959. /*  word width,                                                         */
  960. /*       height;                                                        */
  961. /*  }                                                                   */
  962. /*                                                                      */
  963.  
  964. #define HRWVEC_DATA(S) struct { word length; byte flags, reserved; byte far *buffer; coord_pr coords[S]; }
  965. /* usage: HRWVEC_DATA(size) will give the following structure           */
  966. /*                                                                      */
  967. /*  struct                                                              */
  968. /*  {                                                                   */
  969. /*  word length;                                                        */
  970. /*  byte flags,                                                         */
  971. /*       reserved;                                                      */
  972. /*  byte far *buffer;                                                   */
  973. /*  coord_pr coords[size];                                              */
  974. /*  }                                                                   */
  975. /*                                                                      */
  976.  
  977.  
  978. /* Font file definition                                                 */
  979. /* This is the layout of the font file header                           */
  980. /* All the address fields within the CSD's (Character Set Definition)   */
  981. /* are offsets within the file. To these should be added the address    */
  982. /* at which the font is loaded to give the correct values.              */
  983. /*                                                                      */
  984. struct FontFileDefn
  985. {
  986.   word no_pages; /* no of code pages in the file (size of page_array)   */
  987.   word def_page; /* default page index (into page_array)                */
  988.   word alt_page; /* alternate default page index (into page_array)      */
  989.   struct
  990.   {
  991.     byte code_page_id[4];       /* code page id                         */
  992.     word csd_offset;            /* offset within file of CSD block      */
  993.   } page_array[1];      /* array of code page ID's and CSD offsets      */
  994. };
  995.